import { customAlphabet } from 'nanoid'
import { isArray, isNullOrEmpty, isObject, isSetObject, isString } from './is'

// 获取应用ID
export function $getPublishedApplicationId(): number {
    try {
        const { pathname } = window.location
        const applicationID = pathname.split('/')[1].replace('app_', '')
        return Number(applicationID)
    } catch (e) {
        return 0
    }
}

const nanoid = customAlphabet('1234567890abcdefghijklmnopqrstuvwxyz', 10)
/**
 * 生成唯一ID 可设置随机ID前缀及之间连接符
 *
 * @export
 * @param {string} [prefix]
 * @param {string} [type]
 * @return {*}  {string}
 */
export function randomLetter(count = 1): string {
    return customAlphabet('abcdefghijklmnopqrstuvwxyz', count)()
}

/**
 * 生成唯一ID 可设置随机ID前缀及之间连接符
 *
 * @export
 * @param {string} [prefix]
 * @param {string} [type]
 * @return {*}  {string}
 */
export function createUniqueId(prefix?: string, type = '_'): string {
    let uniqueId = ''
    if (prefix) {
        uniqueId = prefix + type
    }
    return uniqueId + nanoid()
}

/**
 * 数组/对象遍历
 * @param object 要遍历的对象
 * @param formatCallback 要执行的方法
 */
export function $each<T = any>(
    object: Array<T> | Record<string, T> | Set<T>,
    formatCallback: (item: T, index?: number | string) => void
) {
    let index: number | string | T = 0
    if (isArray<T>(object)) {
        // Object 没有length, 只有 Array 有
        const { length } = object
        for (; index < length; index++) {
            formatCallback(object[index], index)
        }
    } else if (isSetObject<T>(object)) {
        for (index of object) {
            formatCallback(index)
        }
    } else if (isObject<T>(object)) {
        for (index in object) {
            formatCallback(object[index], index)
        }
    }
}

/**
 * 持久化信息
 * @param key 存储的key
 * @param content 存储的内容
 */
export function localSave(key: string, content: any) {
    localStorage.setItem(
        key,
        JSON.stringify({
            expire: Date.now() + 1000 * 60 * 60 * 8,
            value: content
        })
    )
}

/**
 * 获取持久化信息
 * @param key 存储的key
 */
export function localGet(key: string) {
    try {
        const result = JSON.parse(localStorage.getItem(key) || '{}')
        if (result.hasOwnProperty('value')) {
            return result.value
        } else {
            return result
        }
    } catch (error) {
        return
    }
}

/**
 * 通用 Storage 存储
 * @param dataKey 存储的key
 * @param value 存储的内容，标准JSON对象
 * @returns {boolean} 存储是否成功
 */
export function setStorage(dataKey: string, value: any) {
    try {
        return localStorage.setItem(dataKey, JSON.stringify(value))
    } catch (error) {
        return false
    }
}
/*
 * 获取存储内容
 * @param dataKey 存储的key
 * @returns {any} 存储的对象
 */
export function getStorageByKey(dataKey: string) {
    try {
        const data = localStorage.getItem(dataKey)
        if (!isNullOrEmpty(data)) {
            return JSON.parse(data as string)
        }
        return null
    } catch (error) {
        return null
    }
}
/**
 * 处理页面跳转
 * @param {String} href 目标URL
 * @param {any} $router 目标URL
 * @param {String} target  跳转方式 _self（默认）当前页跳转， _blank为新页面打开
 * @param {String} routeType  跳转方式： auto（默认） -> 通过判断url中是否包括http判断是否使用a标签进行跳转；a ->强行a标签；router->强行router-link
 */
export function handleRedirect(href: string, $router: any, target = '_self', routeType = 'auto') {
    const isAlink = (routeType === 'auto' && href.indexOf('http') > -1) || routeType === 'a' // 判断是否采用非router路由模式
    let targetUrl = { href } // 构建链接，形式同$router.resolve后的结果
    if (!isAlink) {
        targetUrl = $router.resolve(href) // 如果是router路由模式，通过resolve的方式构建链接用以兼容实现Vue router-link 模式下的新窗口链接（_blank）
    }
    window.open(targetUrl.href, target)
}

/**
 * 封装Json.parse
 * @param {string} str
 * @returns {Object}
 */
export function parseJson(str: string): Object {
    if (!isString(str)) {
        return str;
    }
    try {
        return JSON.parse(str as string);
    } catch (error) {
        return str;
    }
}
